import * as THREE from 'three';
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
import { Base } from 'kokomi.js';
import { SceneManager } from './SceneManager.js';
import { ResourceLoader } from './ResourceLoader.js';
import { PerformanceOptimizer } from './PerformanceOptimizer.js';
import { LoadingUIManager } from './LoadingUIManager.js';
import { ModelRegistry } from './ModelRegistry.js';

export class App3D extends Base {
    constructor(options = {}) {
        // Base类的构造函数接受selector和config参数
        super(options.container || '#scene-container', {
            gl: {
                antialias: options.antialias !== false,
                alpha: options.alpha !== false,
                ...options.gl
            },
            autoRender: false, // 我们手动控制渲染
            ...options.config
        });
        
        this.sceneManager = null;
        this.resourceLoader = null;
        this.performanceOptimizer = null;
        this.loadingUI = null;
        this.modelRegistry = null;
        this.controls = null;
        this.isInitialized = false;
        // 调用父级init
        super.init();
    }
    
    async ready() {
        try {
            // 初始化加载UI管理器
            this.loadingUI = new LoadingUIManager();
            this.loadingUI.show();
            
            // 初始化模型注册表
            this.modelRegistry = new ModelRegistry();
            
            // 初始化基础渲染器
            this.initRenderer();
            
            // 初始化资源加载器
            this.resourceLoader = new ResourceLoader();
            
            // 设置资源加载器的进度回调
            this.setupLoadingCallbacks();
            
            // 预加载所有模型
            await this.preloadAllModels();
            
            // 预加载其他资源
            await this.preloadResources();
            
            // 初始化性能优化器（在渲染器配置完成后）
            this.performanceOptimizer = new PerformanceOptimizer(this);
            
            // 初始化场景管理器
            this.sceneManager = new SceneManager(this);
            
            // 初始化所有场景
            await this.sceneManager.initScenes();
            
            // 设置UI事件
            this.setupUI();
            
            // 启动渲染循环
            this.startRenderLoop();
            
            // 等待用户确认（如果需要）
            await this.waitForUserConfirmation();
            
            this.isInitialized = true;
            
        } catch (error) {
            console.error('App3D初始化失败:', error);
            if (this.loadingUI) {
                this.loadingUI.onLoadingComplete({
                    stats: this.resourceLoader.getStatistics(),
                    loadTime: 0,
                    success: false
                });
            }
            throw error;
        }
    }
    
    initRenderer() {
        // Base类已经创建了渲染器，我们只需要配置它
        this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
        this.renderer.setClearColor(0x000000, 0);
        this.renderer.shadowMap.enabled = true;
        this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
        this.renderer.outputColorSpace = THREE.SRGBColorSpace;
        this.renderer.toneMapping = THREE.ACESFilmicToneMapping;
        this.renderer.toneMappingExposure = 1.2;
        
        // 设置相机
        this.camera.fov = 75;
        this.camera.aspect = window.innerWidth / window.innerHeight;
        this.camera.near = 0.1;
        this.camera.far = 1000;
        this.camera.position.set(0, 0, 5);
        this.camera.updateProjectionMatrix();
        
        // 初始化轨道控制器
        this.initControls();
    }
    
    initControls() {
        // 创建轨道控制器
        this.controls = new OrbitControls(this.camera, this.renderer.domElement);
        
        // 配置控制器
        this.controls.enableDamping = true; // 启用阻尼（惯性）
        this.controls.dampingFactor = 0.05; // 阻尼系数
        this.controls.screenSpacePanning = false; // 禁用屏幕空间平移
        
        // 设置距离限制
        this.controls.minDistance = 2;
        this.controls.maxDistance = 50;
        
        // 设置角度限制
        this.controls.maxPolarAngle = Math.PI; // 允许完全旋转
        
        // 设置平移限制
        this.controls.enablePan = true;
        this.controls.panSpeed = 1.0;
        
        // 设置缩放
        this.controls.enableZoom = true;
        this.controls.zoomSpeed = 1.0;
        
        // 设置旋转
        this.controls.enableRotate = true;
        this.controls.rotateSpeed = 1.0;
        
        // 自动旋转（可选）
        this.controls.autoRotate = false;
        this.controls.autoRotateSpeed = 2.0;
        
        console.log('轨道控制器初始化完成');
    }
    
    async preloadResources() {
        // 预加载基础资源
        const resources = [
            // 几何体场景资源
            {
                name: 'geometryTexture',
                type: 'texture',
                url: null // 程序生成
            },
            // 粒子场景资源
            {
                name: 'particleTexture',
                type: 'texture', 
                url: null // 程序生成
            },
            // 模型场景资源（如果有外部模型的话）
        ];
        
        await this.resourceLoader.loadResources(resources);
    }
    
    setupUI() {
        const buttons = document.querySelectorAll('.scene-btn');
        
        buttons.forEach((button, index) => {
            button.addEventListener('click', () => {
                if (this.sceneManager.currentSceneIndex === index) return;
                
                // 更新按钮状态
                buttons.forEach(btn => btn.classList.remove('active'));
                button.classList.add('active');
                
                // 切换场景
                this.sceneManager.switchToScene(index);
            });
        });
    }
    
    startRenderLoop() {
        // 使用Kokomi.js的update方法来设置渲染循环
        this.update(() => {
            // 更新轨道控制器
            if (this.controls) {
                this.controls.update();
            }
            
            if (this.sceneManager) {
                this.sceneManager.update();
            }
            
            if (this.performanceOptimizer) {
                this.performanceOptimizer.update();
            }
            
            // 手动渲染，因为我们设置了autoRender: false
            this.render();
        });
    }
    
    /**
     * 设置资源加载器的进度回调
     */
    setupLoadingCallbacks() {
        if (!this.resourceLoader || !this.loadingUI) return;
        
        // 总体进度回调
        this.resourceLoader.onProgress = (progressInfo) => {
            if (progressInfo.stage) {
                // 阶段性进度
                this.loadingUI.setMessage(progressInfo.message || '加载中...');
                this.loadingUI.updateProgress(progressInfo.progress, progressInfo.loaded);
            }
        };
        
        // 单个模型进度回调
        this.resourceLoader.onModelProgress = (modelInfo) => {
            this.loadingUI.updateModelProgress(modelInfo);
            
            // 如果模型加载完成
            if (modelInfo.progress >= 1) {
                this.loadingUI.onModelComplete(
                    modelInfo.modelId,
                    modelInfo.fromCache,
                    modelInfo.loadProgress?.total || 0
                );
            }
        };
        
        // 加载完成回调
        this.resourceLoader.onComplete = (result) => {
            console.log('所有模型预加载完成');
            if (this.loadingUI) {
                this.loadingUI.onLoadingComplete(result);
            }
        };
        
        // 错误回调
        this.resourceLoader.onError = (error) => {
            console.error('资源加载错误:', error);
            if (typeof error === 'string') {
                // URL加载错误
                this.loadingUI.onModelError('unknown', error);
            }
        };
    }
    
    /**
     * 预加载所有模型
     */
    async preloadAllModels() {
        if (!this.resourceLoader || !this.modelRegistry) return;
        
        const allModels = this.modelRegistry.getAllModels();
        console.log(`开始预加载 ${allModels.length} 个模型`);
        
        if (this.loadingUI) {
            this.loadingUI.initializeLoading(allModels);
        }
        
        // 执行预加载
        await this.resourceLoader.preloadAllModels();
        
        console.log('模型预加载完成');
    }
    
    /**
     * 获取预加载的模型
     * @param {string} modelId - 模型ID
     * @returns {Object|null} 模型数据
     */
    getPreloadedModel(modelId) {
        return this.resourceLoader ? this.resourceLoader.getPreloadedModel(modelId) : null;
    }
    
    /**
     * 检查模型是否已预加载
     * @param {string} modelId - 模型ID
     * @returns {boolean}
     */
    isModelPreloaded(modelId) {
        return this.resourceLoader ? this.resourceLoader.isModelPreloaded(modelId) : false;
    }
    
    /**
     * 等待用户确认
     */
    async waitForUserConfirmation() {
        return new Promise((resolve) => {
            if (this.loadingUI) {
                // 设置确认回调
                this.loadingUI.setConfirmCallback(() => {
                    console.log('用户确认进入场景');
                    
                    // 激活第一个场景
                    if (this.sceneManager) {
                        this.sceneManager.switchToScene(0).then(() => {
                            console.log('场景激活完成');
                        });
                    }
                    
                    resolve();
                });
            } else {
                // 如果没有加载UI，直接resolve
                resolve();
            }
        });
    }
    
    showLoading() {
        const loading = document.getElementById('loading');
        if (loading) {
            loading.classList.remove('hidden');
        }
    }
    
    hideLoading() {
        const loading = document.getElementById('loading');
        if (loading) {
            setTimeout(() => {
                loading.classList.add('hidden');
            }, 500);
        }
    }
    
    resize() {
        if (!this.isInitialized) return;
        
        const width = window.innerWidth;
        const height = window.innerHeight;
        
        // 通知场景管理器
        if (this.sceneManager) {
            this.sceneManager.onResize(width, height);
        }
        
        // Kokomi.js的Base类已经自动处理相机和渲染器的resize
        // 所以我们不需要手动调用
    }
    
    getRenderer() {
        return this.renderer;
    }
    
    getCamera() {
        return this.camera;
    }
    
    getResourceLoader() {
        return this.resourceLoader;
    }
    
    getPerformanceOptimizer() {
        return this.performanceOptimizer;
    }
    
    getControls() {
        return this.controls;
    }
    
    // 全局遍历所有场景中的mesh
    getAllMeshes() {
        const allMeshes = [];
        
        if (this.sceneManager) {
            this.sceneManager.getAllScenes().forEach(scene => {
                const sceneMeshes = scene.getAllMeshesInGroup();
                allMeshes.push(...sceneMeshes);
            });
        }
        
        return allMeshes;
    }
    
    // 调试所有场景的mesh
    debugAllSceneMeshes() {
        console.log('=== 全局Mesh调试信息 ===');
        
        if (this.sceneManager) {
            this.sceneManager.getAllScenes().forEach((scene, index) => {
                console.log(`\n--- 场景 ${index + 1}: ${scene.name} ---`);
                scene.debugAllMeshes();
            });
        }
        
        const totalMeshes = this.getAllMeshes();
        console.log(`\n总计: ${totalMeshes.length} 个Mesh`);
        
        return totalMeshes;
    }
    
    // 设置所有mesh的可见性（用于调试固定显示的问题）
    setAllMeshesVisible(visible) {
        const meshes = this.getAllMeshes();
        meshes.forEach(mesh => {
            mesh.visible = visible;
        });
        console.log(`全局设置 ${meshes.length} 个mesh的可见性为: ${visible}`);
    }
}
